// 已发送的链接，用于避免重复发送
const sentLinks = new Set();

// 检测到的链接计数
let detectedCount = 0;

// 初始化
function initialize() {
  // 创建MutationObserver监听DOM变化
  const observer = new MutationObserver(mutations => {
    // 检查是否有新的请求
    checkNetworkRequests();
  });
  
  // 开始观察文档变化
  observer.observe(document, {
    childList: true,
    subtree: true
  });
  
  // 初始检查
  checkNetworkRequests();
  
  // 定期检查网络请求
  setInterval(checkNetworkRequests, 5000);
  
  // 监听XHR请求
  monitorXHR();
  
  // 监听fetch请求
  monitorFetch();
}

// 检查网络请求
function checkNetworkRequests() {
  // 使用Performance API获取资源
  if (window.performance && window.performance.getEntriesByType) {
    const resources = window.performance.getEntriesByType('resource');
    
    resources.forEach(resource => {
      const url = resource.name;
      checkUrl(url);
    });
  }
  
  // 检查页面中的视频元素
  const videoElements = document.querySelectorAll('video');
  videoElements.forEach(video => {
    if (video.src) {
      checkUrl(video.src);
    }
    
    // 检查视频元素的source子元素
    const sources = video.querySelectorAll('source');
    sources.forEach(source => {
      if (source.src) {
        checkUrl(source.src);
      }
    });
  });
  
  // 检查页面中的嵌入式播放器
  const embedElements = document.querySelectorAll('embed, iframe');
  embedElements.forEach(embed => {
    if (embed.src) {
      checkUrl(embed.src);
    }
  });
  
  // 检查页面中的链接元素
  const linkElements = document.querySelectorAll('a');
  linkElements.forEach(link => {
    if (link.href) {
      checkUrl(link.href);
    }
  });
  
  // 检查页面中的脚本内容
  const scriptElements = document.querySelectorAll('script');
  scriptElements.forEach(script => {
    if (script.textContent) {
      extractUrlsFromText(script.textContent);
    }
  });
}

// 监控XMLHttpRequest
function monitorXHR() {
  const originalOpen = XMLHttpRequest.prototype.open;
  const originalSend = XMLHttpRequest.prototype.send;
  
  XMLHttpRequest.prototype.open = function(method, url) {
    this._url = url;
    return originalOpen.apply(this, arguments);
  };
  
  XMLHttpRequest.prototype.send = function() {
    const xhr = this;
    
    // 检查请求URL
    if (xhr._url) {
      checkUrl(xhr._url);
    }
    
    // 监听响应
    xhr.addEventListener('load', function() {
      try {
        // 检查响应URL（可能与请求URL不同）
        if (xhr.responseURL) {
          checkUrl(xhr.responseURL);
        }
        
        // 检查响应内容
        if (xhr.responseType === '' || xhr.responseType === 'text') {
          if (xhr.responseText) {
            extractUrlsFromText(xhr.responseText);
          }
        }
      } catch (error) {
        console.error('M3U8检测器: 处理XHR响应时出错', error);
      }
    });
    
    return originalSend.apply(this, arguments);
  };
}

// 监控Fetch API
function monitorFetch() {
  const originalFetch = window.fetch;
  
  window.fetch = function(input, init) {
    // 检查请求URL
    if (typeof input === 'string') {
      checkUrl(input);
    } else if (input instanceof Request) {
      checkUrl(input.url);
    }
    
    // 调用原始fetch并处理响应
    return originalFetch.apply(this, arguments).then(response => {
      // 克隆响应以便我们可以同时读取它
      const clonedResponse = response.clone();
      
      // 检查响应URL
      checkUrl(clonedResponse.url);
      
      // 尝试读取响应内容
      clonedResponse.text().then(text => {
        extractUrlsFromText(text);
      }).catch(() => {
        // 忽略无法读取的响应
      });
      
      return response;
    });
  };
}

// 从文本中提取URL
function extractUrlsFromText(text) {
  if (!text) return;
  
  try {
    // 查找可能的M3U8链接
    // 匹配常见的M3U8 URL模式
    const patterns = [
      /https?:\/\/[^"'\s)]+\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*playlist[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*manifest[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*master[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*index[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*stream[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi,
      /https?:\/\/[^"'\s)]+\/[^"'\s)]*hls[^"'\s)]*\.m3u8([^"'\s)]*)(?=["'\s)]|$)/gi
    ];
    
    patterns.forEach(pattern => {
      const matches = text.match(pattern);
      if (matches) {
        matches.forEach(url => {
          checkUrl(url);
        });
      }
    });
  } catch (error) {
    console.error('M3U8检测器: 提取URL时出错', error);
  }
}

// 检查URL是否为M3U8链接
function checkUrl(url) {
  if (!url || typeof url !== 'string') return;
  
  // 忽略数据URL
  if (url.startsWith('data:')) return;
  
  // 检查URL是否包含.m3u8扩展名或m3u8参数
  const isM3U8 = url.includes('.m3u8') || 
                 url.includes('/m3u8') || 
                 url.includes('format=m3u8') || 
                 url.includes('type=m3u8');
  
  if (isM3U8) {
    // 检查是否已发送此链接
    if (!sentLinks.has(url)) {
      sentLinks.add(url);
      detectedCount++;
      
      // 发送链接到后台脚本
      chrome.runtime.sendMessage({
        action: 'foundM3U8',
        url: url,
        pageUrl: window.location.href,
        pageTitle: document.title
      }, response => {
        if (chrome.runtime.lastError) {
          console.error('M3U8检测器: 发送消息时出错', chrome.runtime.lastError);
          return;
        }
        
        if (response && response.success) {
          console.log('M3U8检测器: 成功发送链接', url);
        }
      });
    }
  }
}

// 启动检测
initialize();